home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 6 / Night Owl's Shareware - PDSI-006 - Night Owl Corp (1990).iso / 001a / mskrmsrc.zip / MSNPDI.ASM < prev    next >
Assembly Source File  |  1991-10-24  |  12KB  |  402 lines
  1.     NAME    MSNPDI
  2. ; File MSNPDI.ASM
  3. ; Packet Driver interface 
  4. ;
  5. ; Copyright (C) 1991, Trustees of Columbia University in the
  6. ;  City of New York.  Permission is granted to any individual or
  7. ;  institution to use, copy, or redistribute this software as long as
  8. ;  it is not sold for profit and this copyright notice is retained.
  9. ; 
  10. ; Written by Joe R. Doupnik, Utah State University, 
  11. ;  jrd@cc.usu.edu, jrd@usu.Bitnet.
  12. ;
  13. ; Edit history
  14. ; Last edit
  15. ; 6 Sept 1991
  16.  
  17. getintv    equ    35h            ; DOS get interrupt vector to es:bx
  18. dos    equ    21h
  19. pdgetinfo    equ    1        ; Packet Driver functions
  20. pd_access     equ    2
  21. pd_release    equ    3
  22. pd_send        equ    4
  23. pd_get_address    equ    6
  24. eaddr_len    equ    6        ; length of an Ethernet address
  25. ETH_MSS        equ    534        ; Correlate with msntcp.h
  26.  
  27. link    struc                ; buffer link structure
  28.     flag    db    0        ; buffer use flag
  29.     bufnum    db    0        ; buffer write/read sequence number
  30.     count    dw    0        ; count of items to follow
  31. link    ends
  32. linksize equ    4            ; bytes in link structure
  33.  
  34. _TEXT    SEGMENT  WORD PUBLIC 'CODE'
  35. _TEXT    ENDS
  36. _DATA    SEGMENT  WORD PUBLIC 'DATA'
  37. _DATA    ENDS
  38. CONST    SEGMENT  WORD PUBLIC 'CONST'
  39. CONST    ENDS
  40. _BSS    SEGMENT  WORD PUBLIC 'BSS'
  41. _BSS    ENDS
  42. DGROUP    GROUP    CONST, _BSS, _DATA
  43.     ASSUME  CS: _TEXT, DS: DGROUP, SS: DGROUP
  44.  
  45. _DATA      SEGMENT
  46.     extrn     _pktbuf_wrote:word, _pktwnum:byte
  47. pdsignature db    'PKT DRVR'        ; signature of a Packet Driver
  48. if_type    dw    0            ; interface type
  49. if_class db    0            ; interface class
  50. if_num    db    0            ; interface number
  51. notype    db    1,2            ; dummy packet type
  52. notypelen equ    $-notype        ; length of type field for notype
  53. pktbufoff dw    0            ; offset of packet buffer
  54. pendingpkt dw    0            ; offset of packet being confirmed
  55. _DATA      ENDS
  56.  
  57. _TEXT    segment
  58.  
  59. pktdrvr    proc    near            ; Packet Driver interrupt invokation
  60. PKTDRVI:int    60h        ; Interrupt number modified by startup code
  61.     ret
  62. pktdrvr    endp
  63.  
  64. ; pdinit(ðeraddress)
  65.  
  66.     public    _pdinit
  67. _pdinit    proc    near
  68.     push    bp
  69.     mov    bp,sp
  70.     push    es
  71.     push    si
  72.     push    di
  73.     push    ds
  74.     mov    ax,dgroup
  75.     mov    ds,ax
  76.     mov    ax,[bp+4+0]        ; get offset of pktbuf
  77.     mov    pktbufoff,ax        ; save locally
  78.  
  79.     mov    cx,60h            ; interrupt range
  80. pdinit1:mov    ah,getintv        ; get interrupt vector
  81.     mov    al,cl            ; vector number
  82.     int    dos
  83.     mov    si,offset dgroup:pdsignature ; look for signature
  84.     push    cx
  85.     mov    cx,length pdsignature    ; length of string
  86.     mov    di,bx
  87.     add    di,3            ; sig starts 3 bytes from entry point
  88.     cld
  89.     repe    cmpsb            ; compare bytes
  90.     pop    cx
  91.     je    pdinit3            ; e = found a match
  92.     inc    cx
  93.     cmp    cx,80h            ; at end of range?
  94.     jna    pdinit1            ; na = not yet, try another int
  95.     stc                ; set carry for failure
  96.     jmp    pdret            ; take failure exit
  97.  
  98. pdinit3:mov    byte ptr PKTDRVI+1,cl    ; force in new PD interrupt, code mod
  99.                     ; find Ethernet address
  100.     mov    ah,pdgetinfo        ; get Packet Driver information
  101.     mov    al,0ffh
  102.     xor    bx,bx            ; optional handle
  103.     push    ds            ; this call changes ds and si
  104.     push    si
  105.     call    pktdrvr
  106.     pop    si
  107.     pop    ds
  108.     jc    pdret            ; c = failure
  109.     mov    if_type,dx        ; save details for access calls
  110.     mov    if_class,ch
  111.     mov    if_num,cl
  112.     mov    ah,pd_access        ; access packets
  113.     mov    al,ch            ; Ethernet class
  114.     mov    bx,dx            ; type
  115.     mov    dl,cl            ; interface number
  116.     mov    cx,notypelen        ; type length for notype
  117.     mov    si,offset dgroup:notype    ; TYPE (should match nothing)
  118.     mov    di,cs
  119.     mov    es,di
  120.     mov    di,offset pdrcvr    ; ES:DI is our Packet Driver receiver
  121.     call    pktdrvr
  122.     jc    pdret            ; c = failure
  123.     mov    bx,ax            ; put handle in bx
  124.     mov    ax,DGROUP        ; our data segment
  125.     mov    es,ax            ; segment of Ethernet address buffer
  126.     mov    di,[bp+4+2]        ; get offset of user's buffer
  127.     mov    cx,eaddr_len        ; length of address wanted
  128.     mov    ah,pd_get_address    ; get the ethernet address
  129.     push    bx            ; save handle
  130.     call    pktdrvr            ; get Ethernet address to es:di buf
  131.     pop    bx
  132.     pushf                ; save carry flag
  133.     mov    ah,pd_release        ; release this type, bx has handle
  134.     call    pktdrvr
  135.     popf                ; recover carry flag
  136. pdret:    mov    ax,1            ; return C status, 1 for success
  137.     jnc    pdret1
  138.     xor    ax,ax            ; 0 for failure
  139. pdret1:    pop    ds            ; success
  140.     pop    di
  141.     pop    si
  142.     pop    es
  143.     mov    sp,bp            ; restore stack
  144.     pop    bp            ; recover bp reg
  145.     ret
  146. _pdinit    endp
  147.  
  148. ; int pdinfo(& int version, & int class, & int pdtype, & int number,
  149. ;  & int functionality)
  150.     public    _pdinfo
  151. _pdinfo    proc    near
  152.     push    bp
  153.     mov    bp,sp
  154.     mov    ah,pdgetinfo        ; get Packet Driver information
  155.     mov    al,0ffh
  156.     xor    bx,bx            ; optional handle
  157.     push    ds            ; this call changes ds and si
  158.     push    si
  159.     call    pktdrvr
  160.     pop    si
  161.     pop    ds
  162.     jc    pdinfo1            ; c = failure
  163.     push    ax            ; save al for later use
  164.     mov    di,[bp+4+0]
  165.     mov    [di],bx            ; return version
  166.     mov    al,ch            ; class
  167.     xor    ah,ah
  168.     mov    di,[bp+4+2]
  169.     mov    [di],ax            ; return as an int
  170.     mov    di,[bp+4+4]
  171.     mov    [di],dx            ; type
  172.     mov    di,[bp+4+6]
  173.     xor    ch,ch
  174.     mov    [di],cx            ; interface number, as an int
  175.     pop    ax            ; recover al
  176.     mov    di,[bp+4+8]
  177.     xor    ah,ah
  178.     mov    [di],ax            ; functionality, as an int
  179. pdinfo1:mov    ax,1            ; C style exit status, 1 = success
  180.     jnc    pdinfo2            ; nc = success
  181.     xor    ax,ax            ; 0 = failure
  182. pdinfo2:pop    bp
  183.     ret
  184. _pdinfo    endp
  185.  
  186. ; int pdclose(int handle)
  187. ; Returns (in AX) 0 if successful, else 1.
  188.     public    _pdclose
  189. _pdclose    proc    near
  190.     push    bp
  191.     mov    bp,sp
  192.     mov    bx,[bp+4+0]        ; handle
  193.     mov    ah,pd_release        ; release_type
  194.     call    pktdrvr
  195.     mov    ax,1            ; assume success
  196.     jnc    pdclos1            ; nc = success
  197.     xor    ax,ax            ; 0 for failure
  198. pdclos1:pop    bp
  199.     ret
  200. _pdclose    endp
  201.  
  202. ; int pdaccess( char *type, typelen, int *handle)
  203. ; Register access for packet TYPE with the Packet Driver
  204.     public    _pdaccess
  205. _pdaccess proc    near
  206.     push    bp
  207.     mov    bp,sp
  208.     push    es
  209.     push    si
  210.     push    di
  211.     push    ds
  212.     push    es
  213.     mov    ax,dgroup        ; set up data segment addressibility
  214.     mov    ds,ax
  215.     mov    al,if_class        ; interface class
  216.     mov    bx,if_type        ; interface type (kind)
  217.     mov    dl,if_num        ; interface number
  218.     xor    dh,dh
  219.     mov    si,[bp+4+0]        ; get offset of packet TYPE buffer
  220.     mov    cx,[bp+4+2]        ; typelen (length of buf contents)
  221.     mov    di,cs            ; ES:DI is our Packet Driver receiver
  222.     mov    es,di
  223.     mov    di,offset pdrcvr    ; local receiver
  224.     mov    ah,pd_access        ; set access
  225.     call    pktdrvr
  226.     jc    pdacc1            ; c = failure
  227.     mov    si,[bp+4+4]        ; offset of handle
  228.     mov    [si],ax            ; return handle
  229. pdacc1:    mov    ax,1            ; C level status, 1 = success
  230.     jnc    pdacc2            ; nc = success
  231.     xor    ax,ax            ; 0 = failure
  232. pdacc2:    pop    es
  233.     pop    ds
  234.     pop    di
  235.     pop    si
  236.     pop    es
  237.     pop    bp
  238.     ret
  239. _pdaccess endp
  240.  
  241. ; int pkt_send( char *buffer, int length)
  242. ; returns 1 on success, 0 on failure
  243.     public    _pkt_send
  244. _pkt_send    proc    near
  245.     push    bp
  246.     mov    bp,sp
  247.     push    ds
  248.     push    si
  249.     mov    ax,dgroup        ; segment of outgoing buffer
  250.     mov    ds,ax            ;  will be DS:SI for Packet Driver
  251.     mov    si,[bp+4+0]        ; buffer's offset
  252.     mov    cx,[bp+4+2]        ; buffer's length
  253.     mov    ah,pd_send        ; send packet (buffer = ds:si)
  254.     call    pktdrvr            ; invoke Packet Driver
  255. pktsen1:mov    ax,1            ; return C level success (1)
  256.     jnc    pktsen2            ; nc = success
  257.     xor    ax,ax            ; else C level failure (0)
  258. pktsen2:pop    si
  259.     pop    ds
  260.          pop    bp
  261.     ret
  262. _pkt_send endp
  263.  
  264. ; Our Packet Driver receiver, far called only by the Packet Driver
  265. ; packet buffer:linked list
  266. ;    each link is    db    flag    ; 1 = free, 2 = in use, 4 = allocated
  267. ;                    ;  but not in use yet, 0 = end of buf
  268. ;                    ; 8 = read but not freed.
  269. ;            db    _pktwnum ; sequential number of pkt written
  270. ;            dw    count    ; length of data field
  271. ;            db count dup (?) ; the allocated data field
  272. ;    The head of the chain has a link like all others.
  273. ;    The end of the chain has a link with flag == 0 and count = -BUFISZE
  274. ;    to point to the beginning of the buffer (circular).
  275. ;    Packet buffer garbage collection is done after the PD transfers a
  276. ;    buffer to the application, and does so by relinking adjacent free
  277. ;    blocks.
  278. ; _pktbuf_wrote is used to remember the link where the last write occurred
  279. ; and should be initialized to the tail link to point the next write to
  280. ; the beginning of the buffer.
  281. ; The Packet Driver calls this first with AX = 0 to obtain a buffer pointer
  282. ; in ES:DI from us (0:0 if we refuse the pkt) with CX = packet size, and
  283. ; again with AX = 1 to post completion.
  284. ; I'm going to turn off interrupts around this code in an attempt to interlock
  285. ; access coherently. It may need to be removed later.
  286.  
  287. pdrcvr    proc    far            ; dummy Packet Driver receiver
  288.     or    ax,ax            ; kind of upcall from PD
  289.     jz    pdrcvr1            ; z = first, get-a-buffer
  290.     ; Second upcall, packet has xfered, ds:si set by PD to xfered buffer
  291.     pushf                ; save interrupt status
  292.     cli                ; interrupts off
  293.      push    ds
  294.     push    si
  295.     push    bx
  296.     push    ax            ; assume ds:si is wrong
  297.      mov    ax,dgroup
  298.     mov    ds,ax            ; set ds to our data segment
  299.     mov    si,pendingpkt        ; offset of pkt being confirmed
  300.     or    si,si            ; is it legal (from first upcall)?
  301.     jz    pdrcvr10        ; z = no, ignore this call
  302.     sub    si,linksize        ; backup to link info
  303.     mov    byte ptr [si].flag,2    ; flag = 2 for buffer is now ready
  304.     mov    al,_pktwnum         ; write packet number sequencer
  305.     mov    [si].bufnum,al
  306.     inc    _pktwnum        ; ready it for next write
  307.  
  308.     mov    si,pktbufoff         ; start of packet buffer
  309.     mov    al,[si]            ; flags byte
  310.                     ; join contiguous free links
  311. pdrcvr8:cmp    al,1            ; link is free?
  312.     jne    pdrcvr9            ; ne = no, look for a free link
  313.     mov    bx,[si].count        ; count of this link
  314.     cmp    byte ptr [bx+si+linksize],1 ; is next link free?
  315.     jne    pdrcvr9            ; ne = no, look for free link
  316.     mov    ax,[bx+si+linksize].count ; count taken from next link
  317.     add    ax,linksize        ;  plus the next link's info field
  318.     add    [si].count,ax        ; add it to this count (merge links)
  319.     jmp    short pdrcvr8        ; reexamine this new longer link
  320.  
  321. pdrcvr9:add    si,[si].count        ; look at next link (add count)
  322.     add    si,linksize        ; and link info
  323.     mov    al,[si].flag        ; get link flags
  324.     or    al,al            ; end of list?
  325.     jnz    pdrcvr8            ; nz = no
  326.     mov    pendingpkt,0        ; say we are done with second upcall
  327. pdrcvr10:pop    ax
  328.     pop    bx
  329.     pop    si
  330.     pop    ds
  331.     popf
  332.     ret                ; yes, quit
  333.  
  334.  
  335. pdrcvr1:pushf
  336.     cli
  337.     push    ds            ; First upcall, provide buf ptr
  338.     push    dx
  339.     push    cx
  340.     mov    di,dgroup        ; get local addressibility
  341.     mov    ds,di
  342.     mov    es,di            ; packet buffer is in same group
  343.     mov    di,_pktbuf_wrote    ; where last write occurred
  344.     or    di,di            ; NULL?
  345.     jz    pdrcvr4            ; z = yes, write nothing
  346.     mov    dl,100            ; retry counter, breaks endless loops
  347.     cmp    [di].flag,1        ; is this place now free?
  348.     je    pdrcvr5            ; e = yes, use it
  349.  
  350. pdrcvr2:add    di,[di].count        ; point at next link (add count and
  351.     add    di,linksize        ;  link overhead)
  352.     dec    dl            ; loop breaker count down
  353.     or    dl,dl
  354.     jz    pdrcvr4            ; z = in an endless loop, exit
  355.     cmp    [di].flag,1        ; is this link free (1)?
  356.     je    pdrcvr5            ; e = yes, setup storage
  357.     cmp    di,_pktbuf_wrote     ; have we come full circle?
  358.     jne    pdrcvr2            ; ne = no, keep looking
  359. pdrcvr4:pop    cx
  360.     pop    dx
  361.     pop    ds            ; failure or buffer not available (0)
  362.     xor    ax,ax            ; return what we received in ax
  363.     xor    di,di            ; return ES:DI as null to reject
  364.     mov    es,di
  365.     popf
  366.     ret
  367.                     ; this link is free
  368. pdrcvr5:cmp    cx,ETH_MSS+40+12 +20    ; LARGEST PACKET WE ACCEPT
  369.     ja    pdrcvr4            ; a = yes, decline it
  370.     add    cx,2            ; defense for 8/16 bit xfr mistakes
  371.     mov    ax,[di].count        ; length of available data space
  372.     cmp    ax,cx            ; cx is incoming size, enough space?
  373.     jl    pdrcvr2            ; l = no, go to next link
  374.     mov    [di].flag,4        ; mark link flag as being alloc'd (4)
  375.     mov    dh,_pktwnum         ; write pkt sequencer number
  376.     mov    [di].bufnum,dh        ; don't inc this til PD is done
  377.     mov    _pktbuf_wrote,di    ; remember where we wrote last
  378.                     ; leave whole area allocated here
  379.     sub    ax,cx            ; allocated minus incoming packet
  380.     cmp    ax,60+linksize        ; enough for new link and miminal pkt?
  381.     jl    pdrcvr6            ; l = not enough for next pkt
  382.     mov    [di].count,cx        ; update space really used
  383.     push    di            ; save this link pointer
  384.     add    di,linksize        ; plus current link info
  385.     add    di,cx            ; plus space used = new link point
  386.     sub    ax,linksize        ; available minus new link info
  387.     mov    [di].flag,1        ; mark new link as free (1)
  388.     mov    [di].count,ax        ; size of new free data area
  389.     pop    di            ; return to current link
  390. pdrcvr6:add    di,linksize        ; point at data portion for Pkt Drvr
  391.     mov    pendingpkt,di        ; preserve in case host does not
  392.     xor    ax,ax            ; return what we received in ax
  393.     pop    cx
  394.     pop    dx
  395.     pop    ds            ; ES:DI is the pkt buffer address
  396.     popf
  397.     ret
  398. pdrcvr    endp
  399. _TEXT    ends
  400.         end
  401.  
  402.